home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / basic / _string.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  6.2 KB  |  307 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _string.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <LEDA/basic.h>
  17.  
  18. #include <stdarg.h>
  19. #include <string.h>
  20. #include <ctype.h>
  21.  
  22.  
  23. //------------------------------------------------------------------------------
  24. // String
  25. //------------------------------------------------------------------------------
  26.  
  27. string_rep::string_rep(const char* p) { s = string::str_dup(p); }
  28.  
  29. string_rep::string_rep(char c)   
  30. { char p[2];
  31.   p[0] = c;
  32.   p[1] = '\0';
  33.   s=string::str_dup(p); 
  34.  }
  35.  
  36. char* string::str_dup(const char* p)
  37. { if (p==nil) error_handler(1,"string::str_dup: nil argument");
  38.   char* q = new char[strlen(p)+1];
  39.   if (q==nil) error_handler(1,"string::str_dup: out of memory");
  40.   strcpy(q,p);
  41.   return q;
  42. }
  43.  
  44. char* string::str_cat(const char* p1, const char* p2)
  45. { char* q = new char[strlen(p1)+strlen(p2)+1];
  46.   if (q==nil) error_handler(1,"string::str_cat: out of memory");
  47.   strcpy(q,p1);
  48.   strcat(q,p2);
  49.   return q;
  50.  }
  51.  
  52. char* string::str_ncat(int argc, char** argv)
  53. { int l=0;
  54.   for(int i=0;i<argc;i++)  l += (strlen(argv[i])+1); 
  55.   char* q = new char[l+1];
  56.   if (q==nil) error_handler(1,"string::str_cat: out of memory");
  57.   q[0] = 0;
  58.   for(i=0;i<argc;i++)
  59.   { strcat(q,argv[i]);
  60.     strcat(q," ");
  61.    }
  62.   return q;
  63.  }
  64.  
  65. void string::read(istream& s, char delim)
  66. { char buf[512];
  67.   char* q = buf+511;
  68.   bool go = true;
  69.  
  70.   operator=(""); // clear string
  71.  
  72.   while (s && go)
  73.   { for(char* p = buf; p < q && s.get(*p); p++)
  74.     { if (*p == delim) 
  75.       { if (delim != '\n') s.putback(*p);
  76.         go = false;
  77.         break;
  78.        }
  79.      } 
  80.     *p = '\0';
  81.     operator+=(buf);
  82.    }
  83.  
  84. }
  85.  
  86.  
  87. #if defined(__GNUG__) || defined(__lucid) || !defined(sparc)
  88.  
  89. string::string(format_string format,...)
  90. { char  buf[512];
  91.   va_list arg_list;
  92.   va_start(arg_list,format);
  93.   vsprintf(buf,format.str,arg_list);
  94.   va_end(arg_list);
  95.   PTR = new string_rep(buf);
  96.  }
  97.  
  98. #else
  99.  
  100. extern "C" void fix_cfront_va_sparc();
  101.  
  102. asm(".seg \"text\"");
  103. asm(".global _fix_cfront_va_sparc");
  104. asm("_fix_cfront_va_sparc:");
  105. asm("retl");
  106. asm("st %i2,[%fp+76]");
  107.  
  108. #define STRING_CONSTRUCTOR(type)\
  109. string::string(const char* format, type, ... )\
  110. { fix_cfront_va_sparc();\
  111.   char buf[512];\
  112.   va_list arg_list;\
  113.   va_start(arg_list,format);\
  114.   vsprintf(buf,format,arg_list);\
  115.   va_end(arg_list);\
  116.   PTR = new string_rep(buf);\
  117.  }
  118.  
  119. STRING_CONSTRUCTOR(int)
  120. STRING_CONSTRUCTOR(long)
  121. STRING_CONSTRUCTOR(float)
  122. STRING_CONSTRUCTOR(double)
  123. STRING_CONSTRUCTOR(char*)
  124. STRING_CONSTRUCTOR(void*)
  125.  
  126. #endif
  127.  
  128.  
  129. int string::length() const  { return strlen(cstring()); }
  130.  
  131. char string::operator[](int i) const
  132. { if (i<0 || length() <= i) 
  133.     error_handler(1,"string[]: index out of range");
  134.   return ptr()->s[i];
  135. }
  136.  
  137. char& string::operator[](int i)
  138. { if (i<0 || length() <= i) 
  139.     error_handler(1,"string[]: index out of range");
  140.   *this = cstring();    //disconnect
  141.   return ptr()->s[i];
  142. }
  143.  
  144. string  string::operator+(const char* x)  const
  145. { char *p = str_cat(cstring(),x);
  146.   string res = p;
  147.   delete p;
  148.   return res;
  149. }
  150.  
  151. string  string::operator+(const string& x)  const
  152. { char *p = str_cat(cstring(),x.cstring());
  153.   string res = p;
  154.   delete p;
  155.   return res;
  156. }
  157.  
  158. string& string::operator+=(const string& x) 
  159. { *this = *this + x; 
  160.   return *this; 
  161.  }
  162.  
  163. //friends
  164.  
  165. int operator==(const string& x, const string& y) 
  166. { return strcmp(x.cstring(),y.cstring())==0; }
  167.  
  168. int operator==(const string& x, const char* y) 
  169. { return strcmp(x.cstring(),y)==0; }
  170.  
  171. int operator!=(const string& x, const string& y) 
  172. { return strcmp(x.cstring(),y.cstring())!=0; }
  173.  
  174. int operator!=(const string& x, const char* y) 
  175. { return strcmp(x.cstring(),y)!=0; }
  176.  
  177. int operator<(const string& x, const string& y)  
  178. { return strcmp(x.cstring(),y.cstring())<0; }
  179.  
  180. int operator>(const string& x, const string& y)  
  181. { return strcmp(x.cstring(),y.cstring())>0; }
  182.  
  183. int operator<=(const string& x, const string& y) 
  184. { return strcmp(x.cstring(),y.cstring())<=0; }
  185.  
  186. int operator>=(const string& x, const string& y) 
  187. { return strcmp(x.cstring(),y.cstring())>=0; }
  188.  
  189.  
  190.  
  191. istream& operator>>(istream& in, string& x)
  192. { char buf[256];
  193.   char* p = buf;
  194.  
  195.   //skip leading white space (but not eol if in = cin)
  196.   while (in.get(*p) && isspace(*p) && (&in != &cin || *p != '\n')); 
  197.  
  198.   if (in && *p != '\n')
  199.   { p++;
  200.     while (in.get(*p) && !isspace(*p)) p++;
  201.    }
  202.  
  203.   *p = '\0';
  204.   x.operator=(buf);
  205.   return in;
  206. }
  207.  
  208.  
  209. ostream& operator<<(ostream& out, const string& x) 
  210. { return out << x.cstring(); }
  211.  
  212.  
  213. string string::sub(int i, int j) const
  214. {
  215.   if (j >= length()) j = length() - 1;
  216.  
  217.   if (i < 0) i = 0;
  218.  
  219.   int l = j-i+1;
  220.  
  221.   if (l <= 0)  return string("");
  222.  
  223.   char* q = new char[l+1];
  224.   strncpy(q,cstring()+i,l);
  225.   q[l] = '\0';
  226.  
  227.   string s(q);
  228.   delete q;
  229.   return s;
  230. }
  231.  
  232. int string::pos(string s1, int i) const
  233. {
  234.   int l1 = s1.length();
  235.   if (l1==0 || i >= length()) return -1;
  236.  
  237.   char c = s1[0];
  238.  
  239.   char* q = cstring() + i;
  240.   while (*q)
  241.     { while ( (*q) && (*q != c) ) q++;
  242.       if ( strncmp(q,s1.cstring(),l1)==0 ) break ;
  243.       if (*q) q++;
  244.      }
  245.   return (*q) ? (q - cstring())/ sizeof(char) :  -1;
  246. }
  247.  
  248. string string::insert(string s, int i) const
  249. { return sub(0,i-1) + s + sub(i,length()-1); }
  250.  
  251. string string::insert(int i, string s) const
  252. { return sub(0,i-1) + s + sub(i,length()-1); }
  253.  
  254.  
  255. string string::del(int i, int j) const
  256. { return sub(0,i-1) + sub(j+1,length()-1); }
  257.  
  258. string string::del(const string& s, int n) const
  259. { return replace(s,"",n); }
  260.  
  261.  
  262.  
  263. string string::replace(int i, int j, const string& s) const
  264. { return sub(0,i-1) + s + sub(j+1,length()-1); }
  265.  
  266. string string::replace(const string& s1, const string& s2, int n) const 
  267. { 
  268.   // replace n-th (all if n=0) occurrence of s1 by s2 
  269.  
  270.   int i = 0;
  271.   int match = 0;  
  272.  
  273.   int l1 = s1.length();
  274.  
  275.   string tmp;
  276.  
  277.   for(;;)
  278.   { int j = pos(s1,i);
  279.     if (j < 0 ) break;
  280.     tmp += sub(i,j-1);
  281.  
  282.     if (n==0 || ++match == n)
  283.        tmp += s2;
  284.     else
  285.        tmp += s1;
  286.  
  287.     i = j+l1;
  288.    }
  289.  
  290.   tmp += sub(i,length()-1);
  291.  
  292.   return tmp;
  293.  
  294.  }
  295.  
  296.  
  297. string string::format(string f) const
  298. { 
  299.   char buf[512];
  300.   sprintf(buf,~f,cstring());
  301.   return buf;
  302.  
  303.  }
  304.  
  305.  
  306. int compare(const string& x, const string& y) { return strcmp(x,y); }
  307.